home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / djgpp / src / gas-211 / gas / messages.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-30  |  9.0 KB  |  396 lines
  1. /* messages.c - error reporter -
  2.    Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
  3.  
  4.    This file is part of GAS, the GNU Assembler.
  5.  
  6.    GAS is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 2, or (at your option)
  9.    any later version.
  10.  
  11.    GAS is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with GAS; see the file COPYING.  If not, write to
  18.    the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19.  
  20. #include <stdio.h>        /* define stderr */
  21. #include <errno.h>
  22.  
  23. #include "as.h"
  24.  
  25. #ifndef __STDC__
  26. #ifndef NO_STDARG
  27. #define NO_STDARG
  28. #endif
  29. #endif
  30.  
  31. #ifndef NO_STDARG
  32. #include <stdarg.h>
  33. #else
  34. #ifndef NO_VARARGS
  35. #include <varargs.h>
  36. #endif /* NO_VARARGS */
  37. #endif /* NO_STDARG */
  38.  
  39. extern char *strerror ();
  40.  
  41. /*
  42.  * Despite the rest of the comments in this file, (FIXME-SOON),
  43.  * here is the current scheme for error messages etc:
  44.  *
  45.  * as_fatal() is used when gas is quite confused and
  46.  * continuing the assembly is pointless.  In this case we
  47.  * exit immediately with error status.
  48.  *
  49.  * as_bad() is used to mark errors that result in what we
  50.  * presume to be a useless object file.  Say, we ignored
  51.  * something that might have been vital.  If we see any of
  52.  * these, assembly will continue to the end of the source,
  53.  * no object file will be produced, and we will terminate
  54.  * with error status.  The new option, -Z, tells us to
  55.  * produce an object file anyway but we still exit with
  56.  * error status.  The assumption here is that you don't want
  57.  * this object file but we could be wrong.
  58.  *
  59.  * as_warn() is used when we have an error from which we
  60.  * have a plausible error recovery.  eg, masking the top
  61.  * bits of a constant that is longer than will fit in the
  62.  * destination.  In this case we will continue to assemble
  63.  * the source, although we may have made a bad assumption,
  64.  * and we will produce an object file and return normal exit
  65.  * status (ie, no error).  The new option -X tells us to
  66.  * treat all as_warn() errors as as_bad() errors.  That is,
  67.  * no object file will be produced and we will exit with
  68.  * error status.  The idea here is that we don't kill an
  69.  * entire make because of an error that we knew how to
  70.  * correct.  On the other hand, sometimes you might want to
  71.  * stop the make at these points.
  72.  *
  73.  * as_tsktsk() is used when we see a minor error for which
  74.  * our error recovery action is almost certainly correct.
  75.  * In this case, we print a message and then assembly
  76.  * continues as though no error occurred.
  77.  */
  78.  
  79. /*
  80.   ERRORS
  81.  
  82.   JF: this is now bogus.  We now print more standard error messages
  83.   that try to look like everyone else's.
  84.  
  85.   We print the error message 1st, beginning in column 1.
  86.   All ancillary info starts in column 2 on lines after the
  87.   key error text.
  88.   We try to print a location in logical and physical file
  89.   just after the main error text.
  90.   Caller then prints any appendices after that, begining all
  91.   lines with at least 1 space.
  92.  
  93.   Optionally, we may die.
  94.   There is no need for a trailing '\n' in your error text format
  95.   because we supply one.
  96.  
  97.   as_warn(fmt,args)  Like fprintf(stderr,fmt,args) but also call errwhere().
  98.  
  99.   as_fatal(fmt,args) Like as_warn() but exit with a fatal status.
  100.  
  101.   */
  102.  
  103. static int warning_count;    /* Count of number of warnings issued */
  104.  
  105. int 
  106. had_warnings ()
  107. {
  108.   return (warning_count);
  109. }                /* had_err() */
  110.  
  111. /* Nonzero if we've hit a 'bad error', and should not write an obj file,
  112.    and exit with a nonzero error code */
  113.  
  114. static int error_count;
  115.  
  116. int 
  117. had_errors ()
  118. {
  119.   return (error_count);
  120. }                /* had_errors() */
  121.  
  122.  
  123. /*
  124.  *            a s _ p e r r o r
  125.  *
  126.  * Like perror(3), but with more info.
  127.  */
  128. void 
  129. as_perror (gripe, filename)
  130.      char *gripe;        /* Unpunctuated error theme. */
  131.      char *filename;
  132. {
  133.   as_where ();
  134.   fprintf (stderr, gripe, filename);
  135.   fprintf (stderr, ": %s\n", strerror (errno));
  136.   errno = 0;            /* After reporting, clear it. */
  137. }                /* as_perror() */
  138.  
  139. /*
  140.  *            a s _ t s k t s k ()
  141.  *
  142.  * Send to stderr a string as a warning, and locate warning
  143.  * in input file(s).
  144.  * Please only use this for when we have some recovery action.
  145.  * Please explain in string (which may have '\n's) what recovery was done.
  146.  */
  147.  
  148. #ifndef NO_STDARG
  149. void 
  150. as_tsktsk (const char *Format,...)
  151. {
  152.   va_list args;
  153.  
  154.   as_where ();
  155.   va_start (args, Format);
  156.   vfprintf (stderr, Format, args);
  157.   va_end (args);
  158.   (void) putc ('\n', stderr);
  159. }                /* as_tsktsk() */
  160.  
  161. #else
  162. #ifndef NO_VARARGS
  163. void 
  164. as_tsktsk (Format, va_alist)
  165.      char *Format;
  166.      va_dcl
  167. {
  168.   va_list args;
  169.  
  170.   as_where ();
  171.   va_start (args);
  172.   vfprintf (stderr, Format, args);
  173.   va_end (args);
  174.   (void) putc ('\n', stderr);
  175. }                /* as_tsktsk() */
  176.  
  177. #else
  178. /*VARARGS1 */
  179. as_tsktsk (Format, args)
  180.      char *Format;
  181. {
  182.   as_where ();
  183.   _doprnt (Format, &args, stderr);
  184.   (void) putc ('\n', stderr);
  185.   /* as_where(); */
  186. }                /* as_tsktsk */
  187.  
  188. #endif /* not NO_VARARGS */
  189. #endif /* not NO_STDARG */
  190.  
  191. /*
  192.  *            a s _ w a r n ()
  193.  *
  194.  * Send to stderr a string as a warning, and locate warning
  195.  * in input file(s).
  196.  * Please only use this for when we have some recovery action.
  197.  * Please explain in string (which may have '\n's) what recovery was done.
  198.  */
  199.  
  200. #ifndef NO_STDARG
  201. void 
  202. as_warn (const char *Format,...)
  203. {
  204.   va_list args;
  205.   char buffer[200];
  206.  
  207.   if (!flag_suppress_warnings)
  208.     {
  209.       ++warning_count;
  210.       as_where ();
  211.       va_start (args, Format);
  212.       fprintf (stderr, "Warning: ");
  213.       vsprintf (buffer, Format, args);
  214.       fputs (buffer, stderr);
  215. #ifndef NO_LISTING
  216.       listing_warning (buffer);
  217. #endif
  218.       va_end (args);
  219.       (void) putc ('\n', stderr);
  220.     }
  221. }                /* as_warn() */
  222.  
  223. #else
  224. #ifndef NO_VARARGS
  225. void 
  226. as_warn (Format, va_alist)
  227.      char *Format;
  228.      va_dcl
  229. {
  230.   va_list args;
  231.   char buffer[200];
  232.  
  233.   if (!flag_suppress_warnings)
  234.     {
  235.       ++warning_count;
  236.       as_where ();
  237.       va_start (args);
  238.       fprintf (stderr, "Warning: ");
  239.       vsprintf (buffer, Format, args);
  240.       fputs (buffer, stderr);
  241. #ifndef NO_LISTING
  242.       listing_warning (buffer);
  243. #endif
  244.       va_end (args);
  245.       (void) putc ('\n', stderr);
  246.     }
  247. }                /* as_warn() */
  248.  
  249. #else
  250. /*VARARGS1 */
  251. as_warn (Format, args)
  252.      char *Format;
  253. {
  254.   if (!flag_suppress_warnings)
  255.     {
  256.       ++warning_count;
  257.       as_where ();
  258.       _doprnt (Format, &args, stderr);
  259.       (void) putc ('\n', stderr);
  260.       /* as_where(); */
  261.     }
  262. }                /* as_warn() */
  263.  
  264. #endif /* not NO_VARARGS */
  265. #endif /* not NO_STDARG */
  266.  
  267. /*
  268.  *            a s _ b a d ()
  269.  *
  270.  * Send to stderr a string as a warning, and locate warning in input file(s).
  271.  * Please us when there is no recovery, but we want to continue processing
  272.  * but not produce an object file.
  273.  * Please explain in string (which may have '\n's) what recovery was done.
  274.  */
  275.  
  276. #ifndef NO_STDARG
  277. void 
  278. as_bad (const char *Format,...)
  279. {
  280.   va_list args;
  281.   char buffer[200];
  282.  
  283.   ++error_count;
  284.   as_where ();
  285.   va_start (args, Format);
  286.   fprintf (stderr, "Error: ");
  287.  
  288.   vsprintf (buffer, Format, args);
  289.   fputs (buffer, stderr);
  290. #ifndef NO_LISTING
  291.   listing_error (buffer);
  292. #endif
  293.   va_end (args);
  294.   (void) putc ('\n', stderr);
  295. }                /* as_bad() */
  296.  
  297. #else
  298. #ifndef NO_VARARGS
  299. void 
  300. as_bad (Format, va_alist)
  301.      char *Format;
  302.      va_dcl
  303. {
  304.   va_list args;
  305.   char buffer[200];
  306.  
  307.   ++error_count;
  308.   as_where ();
  309.   va_start (args);
  310.   vsprintf (buffer, Format, args);
  311.   fputs (buffer, stderr);
  312. #ifndef NO_LISTING
  313.   listing_error (buffer);
  314. #endif
  315.  
  316.   va_end (args);
  317.   (void) putc ('\n', stderr);
  318. }                /* as_bad() */
  319.  
  320. #else
  321. /*VARARGS1 */
  322. as_bad (Format, args)
  323.      char *Format;
  324. {
  325.   ++error_count;
  326.  
  327.   as_where ();
  328.   fprintf (stderr, "Error: ");
  329.   _doprnt (Format, &args, stderr);
  330.   (void) putc ('\n', stderr);
  331.   /* as_where(); */
  332. }                /* as_bad() */
  333.  
  334. #endif /* not NO_VARARGS */
  335. #endif /* not NO_STDARG */
  336.  
  337. /*
  338.  *            a s _ f a t a l ()
  339.  *
  340.  * Send to stderr a string as a fatal message, and print location of error in
  341.  * input file(s).
  342.  * Please only use this for when we DON'T have some recovery action.
  343.  * It exit()s with a warning status.
  344.  */
  345.  
  346. #ifndef NO_STDARG
  347. void 
  348. as_fatal (const char *Format,...)
  349. {
  350.   va_list args;
  351.  
  352.   as_where ();
  353.   va_start (args, Format);
  354.   fprintf (stderr, "FATAL:");
  355.   vfprintf (stderr, Format, args);
  356.   (void) putc ('\n', stderr);
  357.   va_end (args);
  358.   exit (33);
  359. }                /* as_fatal() */
  360.  
  361. #else
  362. #ifndef NO_VARARGS
  363. void 
  364. as_fatal (Format, va_alist)
  365.      char *Format;
  366.      va_dcl
  367. {
  368.   va_list args;
  369.  
  370.   as_where ();
  371.   va_start (args);
  372.   fprintf (stderr, "FATAL:");
  373.   vfprintf (stderr, Format, args);
  374.   (void) putc ('\n', stderr);
  375.   va_end (args);
  376.   exit (33);
  377. }                /* as_fatal() */
  378.  
  379. #else
  380. /*VARARGS1 */
  381. as_fatal (Format, args)
  382.      char *Format;
  383. {
  384.   as_where ();
  385.   fprintf (stderr, "FATAL:");
  386.   _doprnt (Format, &args, stderr);
  387.   (void) putc ('\n', stderr);
  388.   /* as_where(); */
  389.   exit (33);            /* What is a good exit status? */
  390. }                /* as_fatal() */
  391.  
  392. #endif /* not NO_VARARGS */
  393. #endif /* not NO_STDARG */
  394.  
  395. /* end of messages.c */
  396.